home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / dis.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  6KB  |  239 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import sys
  5. import types
  6. from opcode import *
  7. from opcode import __all__ as _opcodes_all
  8. __all__ = [
  9.     'dis',
  10.     'disassemble',
  11.     'distb',
  12.     'disco'] + _opcodes_all
  13. del _opcodes_all
  14.  
  15. def dis(x = None):
  16.     if x is None:
  17.         distb()
  18.         return None
  19.     
  20.     if type(x) is types.InstanceType:
  21.         x = x.__class__
  22.     
  23.     if hasattr(x, 'im_func'):
  24.         x = x.im_func
  25.     
  26.     if hasattr(x, 'func_code'):
  27.         x = x.func_code
  28.     
  29.     if hasattr(x, '__dict__'):
  30.         items = x.__dict__.items()
  31.         items.sort()
  32.         for name, x1 in items:
  33.             if type(x1) in (types.MethodType, types.FunctionType, types.CodeType, types.ClassType):
  34.                 print 'Disassembly of %s:' % name
  35.                 
  36.                 try:
  37.                     dis(x1)
  38.                 except TypeError:
  39.                     msg = None
  40.                     print 'Sorry:', msg
  41.  
  42.                 print 
  43.                 continue
  44.         
  45.     elif hasattr(x, 'co_code'):
  46.         disassemble(x)
  47.     elif isinstance(x, str):
  48.         disassemble_string(x)
  49.     else:
  50.         raise TypeError, "don't know how to disassemble %s objects" % type(x).__name__
  51.  
  52.  
  53. def distb(tb = None):
  54.     if tb is None:
  55.         
  56.         try:
  57.             tb = sys.last_traceback
  58.         except AttributeError:
  59.             raise RuntimeError, 'no last traceback to disassemble'
  60.  
  61.         while tb.tb_next:
  62.             tb = tb.tb_next
  63.     
  64.     disassemble(tb.tb_frame.f_code, tb.tb_lasti)
  65.  
  66.  
  67. def disassemble(co, lasti = -1):
  68.     code = co.co_code
  69.     labels = findlabels(code)
  70.     linestarts = dict(findlinestarts(co))
  71.     n = len(code)
  72.     i = 0
  73.     extended_arg = 0
  74.     free = None
  75.     while i < n:
  76.         c = code[i]
  77.         op = ord(c)
  78.         if i in linestarts:
  79.             if i > 0:
  80.                 print 
  81.             
  82.             print '%3d' % linestarts[i],
  83.         else:
  84.             print '   ',
  85.         if i == lasti:
  86.             print '-->',
  87.         else:
  88.             print '   ',
  89.         if i in labels:
  90.             print '>>',
  91.         else:
  92.             print '  ',
  93.         print repr(i).rjust(4), opname[op].ljust(20),
  94.         i = i + 1
  95.         if op >= HAVE_ARGUMENT:
  96.             oparg = ord(code[i]) + ord(code[i + 1]) * 256 + extended_arg
  97.             extended_arg = 0
  98.             i = i + 2
  99.             if op == EXTENDED_ARG:
  100.                 extended_arg = oparg * 0x10000L
  101.             
  102.             print repr(oparg).rjust(5),
  103.             if op in hasconst:
  104.                 print '(' + repr(co.co_consts[oparg]) + ')',
  105.             elif op in hasname:
  106.                 print '(' + co.co_names[oparg] + ')',
  107.             elif op in hasjrel:
  108.                 print '(to ' + repr(i + oparg) + ')',
  109.             elif op in haslocal:
  110.                 print '(' + co.co_varnames[oparg] + ')',
  111.             elif op in hascompare:
  112.                 print '(' + cmp_op[oparg] + ')',
  113.             elif op in hasfree:
  114.                 if free is None:
  115.                     free = co.co_cellvars + co.co_freevars
  116.                 
  117.                 print '(' + free[oparg] + ')',
  118.             
  119.         
  120.         print 
  121.  
  122.  
  123. def disassemble_string(code, lasti = -1, varnames = None, names = None, constants = None):
  124.     labels = findlabels(code)
  125.     n = len(code)
  126.     i = 0
  127.     while i < n:
  128.         c = code[i]
  129.         op = ord(c)
  130.         if i == lasti:
  131.             print '-->',
  132.         else:
  133.             print '   ',
  134.         if i in labels:
  135.             print '>>',
  136.         else:
  137.             print '  ',
  138.         print repr(i).rjust(4), opname[op].ljust(15),
  139.         i = i + 1
  140.         if op >= HAVE_ARGUMENT:
  141.             oparg = ord(code[i]) + ord(code[i + 1]) * 256
  142.             i = i + 2
  143.             print repr(oparg).rjust(5),
  144.             if op in hasconst:
  145.                 if constants:
  146.                     print '(' + repr(constants[oparg]) + ')',
  147.                 else:
  148.                     print '(%d)' % oparg,
  149.             elif op in hasname:
  150.                 if names is not None:
  151.                     print '(' + names[oparg] + ')',
  152.                 else:
  153.                     print '(%d)' % oparg,
  154.             elif op in hasjrel:
  155.                 print '(to ' + repr(i + oparg) + ')',
  156.             elif op in haslocal:
  157.                 if varnames:
  158.                     print '(' + varnames[oparg] + ')',
  159.                 else:
  160.                     print '(%d)' % oparg,
  161.             elif op in hascompare:
  162.                 print '(' + cmp_op[oparg] + ')',
  163.             
  164.         
  165.         print 
  166.  
  167. disco = disassemble
  168.  
  169. def findlabels(code):
  170.     labels = []
  171.     n = len(code)
  172.     i = 0
  173.     while i < n:
  174.         c = code[i]
  175.         op = ord(c)
  176.         i = i + 1
  177.         if op >= HAVE_ARGUMENT:
  178.             oparg = ord(code[i]) + ord(code[i + 1]) * 256
  179.             i = i + 2
  180.             label = -1
  181.             if op in hasjrel:
  182.                 label = i + oparg
  183.             elif op in hasjabs:
  184.                 label = oparg
  185.             
  186.             if label >= 0:
  187.                 if label not in labels:
  188.                     labels.append(label)
  189.                 
  190.             
  191.         label >= 0
  192.     return labels
  193.  
  194.  
  195. def findlinestarts(code):
  196.     byte_increments = [ ord(c) for c in code.co_lnotab[0::2] ]
  197.     line_increments = [ ord(c) for c in code.co_lnotab[1::2] ]
  198.     lastlineno = None
  199.     lineno = code.co_firstlineno
  200.     addr = 0
  201.     for byte_incr, line_incr in zip(byte_increments, line_increments):
  202.         if byte_incr:
  203.             addr += byte_incr
  204.         
  205.         lineno += line_incr
  206.     
  207.     if lineno != lastlineno:
  208.         yield (addr, lineno)
  209.     
  210.  
  211.  
  212. def _test():
  213.     if sys.argv[1:]:
  214.         if sys.argv[2:]:
  215.             sys.stderr.write('usage: python dis.py [-|file]\n')
  216.             sys.exit(2)
  217.         
  218.         fn = sys.argv[1]
  219.         if not fn or fn == '-':
  220.             fn = None
  221.         
  222.     else:
  223.         fn = None
  224.     if fn is None:
  225.         f = sys.stdin
  226.     else:
  227.         f = open(fn)
  228.     source = f.read()
  229.     if fn is not None:
  230.         f.close()
  231.     else:
  232.         fn = '<stdin>'
  233.     code = compile(source, fn, 'exec')
  234.     dis(code)
  235.  
  236. if __name__ == '__main__':
  237.     _test()
  238.  
  239.